﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace Test1
{
    //接口
    interface iCatchMice
    {
        void CatchMice();
    }
    interface iClimbTree
    {
        void ClimbTree();
    }
    //抽象类
   abstract public class Pet
    {
  
        public Pet(string name)
        {
            _name = name;
        }

        //抽象类
        abstract public void Sing();

       protected  string _name;
        public void PrintName()
        {

            Console.WriteLine("pet name {0}",_name);
        }
        //声明virtual 的方法就是虚方法。
        virtual public void Speak()
        {
            Console.WriteLine(_name+"IS SPEAKING HAHA");
        }
       
    }
    //静态类
   static class PetGuide
   {
       static public void HowToFeedCat(this Cat cat)
       {
           Console.WriteLine("HowToFeedCat");
       }
   }

   
   public class Cat : Pet, iClimbTree,iCatchMice
      {
       //static int num;
       //事件
       public delegate void Handler();
       public static event Handler NewCat;
       

      public void CatchMice()
       {
           Console.WriteLine(" CatchMice");
       }
      public void ClimbTree()
       {
           Console.WriteLine("ClimbTree");
       }
       
        public Cat(string name):base(name)
        {
            _name = name;
        }

        //添加new关键字，否则会有警告
 
        new public void PrintName()
        {
            
            Console.WriteLine("这是用的new生成的类 {0}",_name);
        }
        //基类的虚方法可以在派生类中使用override进行重写
        override public void Speak()
        {
            Console.WriteLine(_name + "IS SPEAKING MIAOMIAO");
       }
        //抽象类 重写
        override public void Sing()
        {
            Console.WriteLine(_name + "ISsinging  a  song");
        }

        public void WagTail()
        {
            Console.WriteLine(_name+"wag tail");
        }


       //事件
        public void Addnum()
        {

            if (NewCat != null)
            {
                NewCat();
            }
           
        }
    }



   class Client
   {
       public void wantAcat()
       {
           Console.WriteLine("i  want a cat");
       }
   }
    class Program
    {
        //委托
       delegate void ActCute();

        static void Main(string[] args)
        {
            ActCute del = null;
            Cat catCute = new Cat("catcute");
            del = catCute.WagTail;
           
        
            del = () =>
                {
                    Console.WriteLine("do nothing");

                };
            del();


            
            //People man = new People();
           // man.Name = "123";
            //man.Sex = "男";
            //Console.WriteLine("我是{0},性别{1}",man.Age,man.Sex);
           // Cat cat1 = new Cat();
           // cat1._name = "ali";
           // cat1.PrintName();
           // cat1.Speak();
            Cat cat2 = new Cat("amao");
            cat2.Speak();
            cat2.Sing();
            iCatchMice catchM = (iCatchMice)cat2;
            // cat2.CatchMice(); // 可以通过接口引用调用接口中的方法，也可通过实例调用接口方法
              catchM.CatchMice();
              iClimbTree CLIMG = (iClimbTree)cat2;
              cat2.ClimbTree();

              Cat cat3 = new Cat("tom");
              cat3.HowToFeedCat();

            //集合
              List<Cat> list = new List<Cat>();
              list.Add(new Cat("add1Cat"));
              list.Add(new Cat("add2Cat"));
             

              for (int i = 0; i < list.Count; i++)
              {
                  list[i].PrintName();
              }

              Dictionary<string, Cat> dic = new Dictionary<string, Cat>();
              dic.Add("dic1Cat", new Cat("dic1Cat"));


            //事件
              Client c1 = new Client();
              Client c2 = new Client();
              Cat.NewCat += c1.wantAcat;
              Cat.NewCat += c2.wantAcat;
           
             
              Cat shijianCat = new Cat("shijianA");
              shijianCat.Addnum();
              
           
             
             

        }
    }
}
/*
面向对象编程
 * 封装
 * 继承 一个类派生出来另外一个类
 * 多态
 * 优点：易维护 易扩展 易开发
object类是所有类的共同基类
 * 单继承
 * 
 * 隐藏方法
 * 屏蔽数据成员 
 * 屏蔽函数成员
 *让编译器知道：可以添加new关键字，否则会有警告
 *
 依赖于抽象类，而不依赖与具体类
 *虚方法和多态
 *虚方法：声明virtual 的方法就是虚方法。基类的虚方法可以在派生类中使用override进行重写
 *多态：通过指向派生类的基类引用，调用虚方法，会根据引用所指向派生类的实际类型，调用派生类中的同名重写函数，便是多态
 *重写虚方法必须具有相同的访问性，且基类方法不能用private
 *不能重写static方法或者非虚方法
 *方法，属性，索引器，事件。都可以声明为virtual或者override

抽象类和抽象方法
 * abstract  抽象类不能实例化
 * 
 * 密闭类和密闭方法 sealed
 * 密闭类：有些类不希望其他人通过继承来修改
 * 密闭方法不希望其他人重写该方法
 * 若派生类中的重写方法（用override修饰的方法）不想再被重写，则可以同时用override和sealed进行修饰。

接口
 * 1、接口就是制定一组函数成员，而不实现他们的引用类型，用interface声明。接口函数不能用其他访问修饰符修饰，默认为public。
2、接口用来被实现
例如Cat:ICatchMice{
//实现接口函数
}
3、一个类可以实现多个接口，当一个类同时继承基类和实现接口时，应该将基类写在最前面，用逗号隔开
4、一个类实现接口时，必须实现接口声明的函数。
5、可以通过接口引用调用接口中的方法，也可通过实例调用接口方法
 * 
 * 结构和类
 * 结构是值类型（在栈中），类是引用类型（在堆中）
结构不支持继承，类支持继承
结构不定义默认构造函数，编译器会定义
 * 
 * 静态成员和静态类
 * 
 * 
 * 
 * 重载运算符
 * 装箱和拆箱
 * 自定义转换定义：
为自己的结构或者类定义显示和隐式的转换
隐式转换的语法：public static implicit operator Dog(Cat cat)
//implicit+operator+返回类型（目标类型）+参数（源类型）
显示转换的语法：public static explicit operator Dog(Cat cat)
//explicit+operator+返回类型（目标类型）+参数（源类型）
 * 重载运算符
 * 不能重载：= ，&& ，|| ,[],()等等
 * 
 * 泛型类
 * 泛型方法 就是方法的模型，给定具体的类型，就可以实例化出一个操作该类型的具体方法
 * 泛型接口  允许我们将接口成员的参数和返回类型设置为泛型参数的接口
 * 泛型接口语法
 *    interface IMyself<T>
 *    {
 *      T Myself(T self);
 *    }
 *    
 * 集合
 * 动态数组ArrayList
 * 初始化，可以不指定大小
 * 获取长度，使用count 属性
 * 添加Add
 * 删除remove,removeat
 * 访问[index]
 *
 * 字典 
 * 数量count 添加add(key value)  删除 remove 访问 [key]
 *
 * 栈  pop　ｐｕｓｈ　获取栈顶元素ｐｅｅｋ
 * 
 * 队列 先进先出
 * 
 * 
 * 委托
 * Lambda表达式
 * 事件  订阅 +=     取消订阅—=
  封装的受限制的委托


*/